home *** CD-ROM | disk | FTP | other *** search
/ Amiga Tools 1 / Amiga Tools.iso / wb-tools / toolmanager / source / library / objects.c < prev    next >
C/C++ Source or Header  |  1994-06-06  |  11KB  |  295 lines
  1. /*
  2.  * objects.c  V2.1
  3.  *
  4.  * TMObject managment routines
  5.  *
  6.  * (c) 1990-1993 Stefan Becker
  7.  */
  8.  
  9. #include "ToolManagerLib.h"
  10.  
  11. static void *dummyfunc(void) {return(NULL);};
  12.  
  13. /* object functions arrays */
  14. struct TMObject *CreateTMObjectExec(struct TMHandle *, char *,
  15.                                     struct TagItem *);
  16. struct TMObject *CreateTMObjectImage(struct TMHandle *, char *,
  17.                                      struct TagItem *);
  18. struct TMObject *CreateTMObjectSound(struct TMHandle *, char *,
  19.                                      struct TagItem *);
  20. struct TMObject *CreateTMObjectMenu(struct TMHandle *, char *,
  21.                                     struct TagItem *);
  22. struct TMObject *CreateTMObjectIcon(struct TMHandle *, char *,
  23.                                     struct TagItem *);
  24. struct TMObject *CreateTMObjectDock(struct TMHandle *, char *,
  25.                                     struct TagItem *);
  26. struct TMObject *CreateTMObjectAccess(struct TMHandle *, char *,
  27.                                       struct TagItem *);
  28. typedef struct TMObject *(*CreateFuncPtr)(struct TMHandle *, char *,
  29.                                           struct TagItem *);
  30. static CreateFuncPtr CreateFuncTab[TMOBJTYPES]={CreateTMObjectExec,
  31.                                                 CreateTMObjectImage,
  32.                                                 CreateTMObjectSound,
  33.                                                 CreateTMObjectMenu,
  34.                                                 CreateTMObjectIcon,
  35.                                                 CreateTMObjectDock,
  36.                                                 CreateTMObjectAccess};
  37.  
  38. BOOL DeleteTMObjectExec(struct TMObject *);
  39. BOOL DeleteTMObjectImage(struct TMObject *);
  40. BOOL DeleteTMObjectSound(struct TMObject *);
  41. BOOL DeleteTMObjectMenu(struct TMObject *);
  42. BOOL DeleteTMObjectIcon(struct TMObject *);
  43. BOOL DeleteTMObjectDock(struct TMObject *);
  44. BOOL DeleteTMObjectAccess(struct TMObject *);
  45. typedef BOOL (*DeleteFuncPtr)(struct TMObject *);
  46. static DeleteFuncPtr DeleteFuncTab[TMOBJTYPES]={DeleteTMObjectExec,
  47.                                                 DeleteTMObjectImage,
  48.                                                 DeleteTMObjectSound,
  49.                                                 DeleteTMObjectMenu,
  50.                                                 DeleteTMObjectIcon,
  51.                                                 DeleteTMObjectDock,
  52.                                                 DeleteTMObjectAccess};
  53.  
  54. BOOL ChangeTMObjectExec(struct TMHandle *, struct TMObject *,
  55.                         struct TagItem *);
  56. /* BOOL ChangeTMObjectImage(struct TMHandle *, struct TMObject *,
  57.                          struct TagItem *); */
  58. BOOL ChangeTMObjectSound(struct TMHandle *, struct TMObject *,
  59.                          struct TagItem *);
  60. BOOL ChangeTMObjectMenu(struct TMHandle *, struct TMObject *,
  61.                         struct TagItem *);
  62. BOOL ChangeTMObjectIcon(struct TMHandle *, struct TMObject *,
  63.                         struct TagItem *);
  64. BOOL ChangeTMObjectDock(struct TMHandle *, struct TMObject *,
  65.                         struct TagItem *);
  66. BOOL ChangeTMObjectAccess(struct TMHandle *, struct TMObject *,
  67.                           struct TagItem *);
  68. typedef BOOL (*ChangeFuncPtr)(struct TMHandle *, struct TMObject *,
  69.                               struct TagItem *);
  70. static ChangeFuncPtr ChangeFuncTab[TMOBJTYPES]={ChangeTMObjectExec,
  71.                                                 dummyfunc,
  72.                                                 ChangeTMObjectSound,
  73.                                                 ChangeTMObjectMenu,
  74.                                                 ChangeTMObjectIcon,
  75.                                                 ChangeTMObjectDock,
  76.                                                 ChangeTMObjectAccess};
  77.  
  78. struct TMLink *AllocLinkTMObjectExec(struct TMObject *);
  79. struct TMLink *AllocLinkTMObjectImage(struct TMObject *);
  80. struct TMLink *AllocLinkTMObjectSound(struct TMObject *);
  81. struct TMLink *AllocLinkTMObjectDock(struct TMObject *);
  82. struct TMLink *AllocLinkTMObjectAccess(struct TMObject *);
  83. typedef struct TMLink *(*AllocLinkFuncPtr)(struct TMObject *);
  84. static AllocLinkFuncPtr AllocLinkFuncTab[TMOBJTYPES]={AllocLinkTMObjectExec,
  85.                                                       AllocLinkTMObjectImage,
  86.                                                       AllocLinkTMObjectSound,
  87.                                                       dummyfunc,
  88.                                                       dummyfunc,
  89.                                                       AllocLinkTMObjectDock,
  90.                                                       AllocLinkTMObjectAccess};
  91.  
  92. void DeleteLinkTMObjectExec(struct TMLink *);
  93. void DeleteLinkTMObjectMenu(struct TMLink *);
  94. void DeleteLinkTMObjectIcon(struct TMLink *);
  95. void DeleteLinkTMObjectDock(struct TMLink *);
  96. void DeleteLinkTMObjectAccess(struct TMLink *);
  97. typedef void (*DeleteLinkFuncPtr)(struct TMLink *);
  98. static DeleteLinkFuncPtr DeleteLinkFuncTab[TMOBJTYPES]={DeleteLinkTMObjectExec,
  99.                                                         dummyfunc,
  100.                                                         dummyfunc,
  101.                                                         DeleteLinkTMObjectMenu,
  102.                                                         DeleteLinkTMObjectIcon,
  103.                                                         DeleteLinkTMObjectDock,
  104.                                                      DeleteLinkTMObjectAccess};
  105.  
  106. void ActivateTMObjectExec(struct TMLink *, void *);
  107. void ActivateTMObjectImage(struct TMLink *, void *);
  108. void ActivateTMObjectSound(struct TMLink *, void *);
  109. void ActivateTMObjectMenu(struct TMLink *, void *);
  110. void ActivateTMObjectIcon(struct TMLink *, void *);
  111. void ActivateTMObjectDock(struct TMLink *, void *);
  112. void ActivateTMObjectAccess(struct TMLink *, void *);
  113. typedef void (*ActivateFuncPtr)(struct TMLink *, void *);
  114. static ActivateFuncPtr ActivateFuncTab[TMOBJTYPES]={ActivateTMObjectExec,
  115.                                                     ActivateTMObjectImage,
  116.                                                     ActivateTMObjectSound,
  117.                                                     ActivateTMObjectMenu,
  118.                                                     ActivateTMObjectIcon,
  119.                                                     ActivateTMObjectDock,
  120.                                                     ActivateTMObjectAccess};
  121.  
  122. /* Allocate a TMObject structure */
  123. struct TMObject *AllocateTMObject(ULONG size)
  124. {
  125.  struct TMObject *tmobj;
  126.  
  127.  /* Get memory for TMObject */
  128.  if (tmobj=AllocMem(size,MEMF_CLEAR|MEMF_PUBLIC)) {
  129.   /* Init link list */
  130.   NewList(&tmobj->tmo_Links);
  131.  
  132.   /* All OK */
  133.   return(tmobj);
  134.  }
  135.  
  136.  /* call failed */
  137.  return(NULL);
  138. }
  139.  
  140. /* Find an object by name of a specified type */
  141. static struct TMObject *FindObjectInList(struct TMHandle *handle, char *name,
  142.                                          UBYTE type)
  143. {
  144.  struct TMObject *tmobj=GetHead(&handle->tmh_ObjectLists[type]);
  145.  
  146.  /* Scan list */
  147.  while (tmobj)
  148.   if (strcmp(name,tmobj->tmo_Name))
  149.    tmobj=GetSucc(tmobj);            /* Object not found --> Next object */
  150.   else
  151.    break;                           /* Object found --> Leave loop */
  152.  
  153.  /* return pointer to object */
  154.  return(tmobj);
  155. }
  156.  
  157. /* Find an object by name in a specified TMHandle */
  158. static struct TMObject *FindObjectInTMHandle(struct TMHandle *handle,
  159.                                              char *name)
  160. {
  161.  int i;
  162.  struct TMObject *tmobj;
  163.  
  164.  /* Scan all lists in TMHandle */
  165.  for (i=0; i<TMOBJTYPES; i++)
  166.   if (tmobj=FindObjectInList(handle,name,i)) break; /* Object found */
  167.  
  168.  /* return pointer to object */
  169.  return(tmobj);
  170. }
  171.  
  172. /* Create a TMObject of the specified type */
  173. BOOL InternalCreateTMObject(struct TMHandle *handle, char *object, ULONG type,
  174.                             struct TagItem *tags)
  175. {
  176.  struct TMObject *tmobj;
  177.  
  178.  /* Call type specific create function */
  179.  if (tmobj=(*CreateFuncTab[type])(handle,object,tags)) {
  180.   /* Object created */
  181.   tmobj->tmo_Type=type;
  182.   tmobj->tmo_Name=object;
  183.  
  184.   /* Add it to the TMHandle */
  185.   AddTail(&handle->tmh_ObjectLists[type],(struct Node *) tmobj);
  186.  
  187.   /* call succeeded */
  188.   return(TRUE);
  189.  }
  190.  
  191.  /* call failed */
  192.  return(FALSE);
  193. }
  194.  
  195. /* Delete a TMObject (NOTE: object MUST Remove() itself from list!!!) */
  196. BOOL CallDeleteTMObject(struct TMObject *tmobj)
  197. {
  198.  return((*DeleteFuncTab[tmobj->tmo_Type])(tmobj));
  199. }
  200.  
  201. /* Delete a TMObject (NOTE: object MUST Remove() itself from list!!!) */
  202. BOOL InternalDeleteTMObject(struct TMHandle *handle, char *object)
  203. {
  204.  struct TMObject *tmobj;
  205.  
  206.  /* find object */
  207.  if (tmobj=FindObjectInTMHandle(handle,object))
  208.   /* Object found, remove delete it */
  209.   return((*DeleteFuncTab[tmobj->tmo_Type])(tmobj));
  210.  
  211.  /* call failed */
  212.  return(FALSE);
  213. }
  214.  
  215. /* Change a TMObject */
  216. BOOL InternalChangeTMObject(struct TMHandle *handle, char *object,
  217.                             struct TagItem *tags)
  218. {
  219.  struct TMObject *tmobj;
  220.  
  221.  /* find object */
  222.  if (tmobj=FindObjectInTMHandle(handle,object)){
  223.   /* Object found */
  224.  
  225.   /* any tags specified? */
  226.   if (tags==NULL) return(TRUE); /* call succeeded :-) */
  227.  
  228.   /* Change object */
  229.   return((ChangeFuncTab[tmobj->tmo_Type])(handle,tmobj,tags));
  230.  }
  231.  
  232.  /* call failed */
  233.  return(FALSE);
  234. }
  235.  
  236. /* Add a link to a TMObject */
  237. struct TMLink *AddLinkTMObject(struct TMHandle *handle, char *object,
  238.                                ULONG type, struct TMObject *linkedto)
  239. {
  240.  struct TMObject *tmobj;
  241.  
  242.  /* Find object of specified type */
  243.  if (tmobj=FindObjectInList(handle,object,type)) {
  244.   struct TMLink *tml;
  245.  
  246.   /* Allocate TMLink structure */
  247.   if (tml=(AllocLinkFuncTab[tmobj->tmo_Type])(tmobj)) {
  248.    /* Initialize link */
  249.    tml->tml_Linked=tmobj;
  250.    tml->tml_LinkedTo=linkedto;
  251.  
  252.    /* Add link to list */
  253.    AddTail(&tmobj->tmo_Links,(struct Node *) tml);
  254.  
  255.    /* All OK */
  256.    return(tml);
  257.   }
  258.  }
  259.  
  260.  /* call failed */
  261.  return(NULL);
  262. }
  263.  
  264. /* Remove a link to a TMObject */
  265. void RemLinkTMObject(struct TMLink *tml)
  266. {
  267.  /* Remove it from list */
  268.  Remove((struct Node *) tml);
  269.  
  270.  /* Free link structure */
  271.  FreeMem(tml,tml->tml_Size);
  272. }
  273.  
  274. /* Remove all links to a TMObject (updating objects this object is linked to) */
  275. void DeleteAllLinksTMObject(struct TMObject *tmobj)
  276. {
  277.  struct List *l=&tmobj->tmo_Links;
  278.  struct TMLink *tml;
  279.  
  280.  /* Scan list */
  281.  while (tml=(struct TMLink *) RemHead(l)) {
  282.   /* Notify linkedTo object, that this link will be removed */
  283.   (DeleteLinkFuncTab[tml->tml_LinkedTo->tmo_Type])(tml);
  284.  
  285.   /* Free link structure */
  286.   FreeMem(tml,tml->tml_Size);
  287.  }
  288. }
  289.  
  290. /* Activate a TMObject */
  291. void CallActivateTMObject(struct TMLink *tml, void *args)
  292. {
  293.  (ActivateFuncTab[tml->tml_Linked->tmo_Type])(tml,args);
  294. }
  295.